Documentazione di Tornado: Una Guida Completa per Sviluppatori di Tutto il Mondo

Tornado è un web framework Python e una libreria di networking asincrono, originariamente sviluppato presso FriendFeed. È particolarmente adatto per long-polling, WebSockets e altre applicazioni che richiedono una connessione di lunga durata con ogni utente. Il suo I/O di rete non bloccante lo rende estremamente scalabile e una scelta potente per la creazione di applicazioni web ad alte prestazioni. Questa guida completa ti guiderà attraverso i concetti fondamentali di Tornado e fornirà esempi pratici per iniziare.

Cos'è Tornado?

Nel suo nucleo, Tornado è un web framework e una libreria di networking asincrono. A differenza dei tradizionali web framework sincroni, Tornado utilizza un'architettura a singolo thread basata su un event loop. Ciò significa che può gestire molte connessioni concorrenti senza richiedere un thread per connessione, rendendolo più efficiente e scalabile.

Caratteristiche Principali di Tornado:

• Networking Asincrono: Il nucleo di Tornado è costruito attorno all'I/O asincrono, permettendogli di gestire migliaia di connessioni concorrenti in modo efficiente.
• Web Framework: Include funzionalità come gestori di richieste, routing, templating e autenticazione, rendendolo un web framework completo.
• Supporto WebSocket: Tornado fornisce un eccellente supporto per i WebSockets, consentendo la comunicazione in tempo reale tra il server e i client.
• Leggero e Veloce: Progettato per le prestazioni, Tornado è leggero ed efficiente, minimizzando l'overhead e massimizzando il throughput.
• Facile da Usare: Nonostante le sue funzionalità avanzate, Tornado è relativamente facile da imparare e utilizzare, con un'API chiara e ben documentata.

Configurare l'Ambiente Tornado

Prima di immergersi nello sviluppo con Tornado, è necessario configurare il proprio ambiente. Ecco una guida passo-passo:

1. Installa Python: Assicurati di avere installato Python 3.6 o superiore. Puoi scaricarlo dal sito ufficiale di Python (python.org).
2. Crea un Ambiente Virtuale (Consigliato): Usa venv o virtualenv per creare un ambiente isolato per il tuo progetto:

               python3 -m venv myenv
   source myenv/bin/activate  # Su Linux/macOS
   myenv\Scripts\activate  # Su Windows
               
   
                 
                   Copy
                 
               
             

3. Installa Tornado: Installa Tornado usando pip:

               pip install tornado
               
   
                 
                   Copy
                 
               
             

La Tua Prima Applicazione Tornado

Creiamo una semplice applicazione "Hello, World!" con Tornado. Crea un file chiamato app.py e aggiungi il seguente codice:

            import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
 def get(self):
  self.write("Hello, World!")

def make_app():
 return tornado.web.Application([
  (r"/", MainHandler),
 ])

if __name__ == "__main__":
 app = make_app()
 app.listen(8888)
 tornado.ioloop.IOLoop.current().start()
            

              
                Copy
              
            
          

Ora, esegui l'applicazione dal tuo terminale:

            python app.py
            

              
                Copy
              
            
          

Apri il tuo browser web e vai a http://localhost:8888. Dovresti vedere il messaggio "Hello, World!".

Spiegazione:

• tornado.ioloop: Il ciclo degli eventi (event loop) principale che gestisce le operazioni asincrone.
• tornado.web: Fornisce i componenti del web framework, come i gestori di richieste e il routing.
• MainHandler: Un gestore di richieste che definisce come gestire le richieste HTTP in arrivo. Il metodo get() viene chiamato per le richieste GET.
• tornado.web.Application: Crea l'applicazione Tornado, mappando i pattern degli URL ai gestori di richieste.
• app.listen(8888): Avvia il server, mettendolo in ascolto delle connessioni in arrivo sulla porta 8888.
• tornado.ioloop.IOLoop.current().start(): Avvia il ciclo degli eventi, che elabora le richieste in arrivo e gestisce le operazioni asincrone.

Request Handler e Routing

I gestori di richieste (request handler) sono le fondamenta delle applicazioni web Tornado. Definiscono come gestire le richieste HTTP in arrivo in base all'URL. Il routing mappa gli URL a specifici gestori di richieste.

Definire i Request Handler:

Per creare un gestore di richieste, si sottoclassa tornado.web.RequestHandler e si implementano i metodi HTTP appropriati (get, post, put, delete, ecc.).

            class MyHandler(tornado.web.RequestHandler):
 def get(self):
  self.write("Questa è una richiesta GET.")

 def post(self):
  data = self.request.body.decode('utf-8')
  self.write(f"Dati POST ricevuti: {data}")
            

              
                Copy
              
            
          

Routing:

Il routing viene configurato durante la creazione di tornado.web.Application. Si fornisce una lista di tuple, dove ogni tupla contiene un pattern di URL e il gestore di richieste corrispondente.

            app = tornado.web.Application([
 (r"/", MainHandler),
 (r"/myhandler", MyHandler),
])
            

              
                Copy
              
            
          

Pattern degli URL:

I pattern degli URL sono espressioni regolari. È possibile utilizzare gruppi di espressioni regolari per catturare parti dell'URL e passarle come argomenti ai metodi del gestore di richieste.

            class UserHandler(tornado.web.RequestHandler):
 def get(self, user_id):
  self.write(f"ID Utente: {user_id}")

app = tornado.web.Application([
 (r"/user/([0-9]+)", UserHandler),
])
            

              
                Copy
              
            
          

In questo esempio, /user/([0-9]+) corrisponde a URL come /user/123. La parte ([0-9]+) cattura una o più cifre e le passa come argomento user_id al metodo get di UserHandler.

Templating

Tornado include un motore di templating semplice ed efficiente. I template vengono utilizzati per generare HTML dinamicamente, separando la logica di presentazione dalla logica dell'applicazione.

Creare i Template:

I template sono tipicamente memorizzati in file separati (es. index.html). Ecco un semplice esempio:

            <!DOCTYPE html>
<html>
<head>
 <title>Il Mio Sito Web</title>
</head>
<body>
 <h1>Benvenuto, {{ name }}!</h1>
 <p>Oggi è il {{ today }}.</p>
</body>
</html>
            

              
                Copy
              
            
          

{{ name }} e {{ today }} sono segnaposto che verranno sostituiti con valori effettivi quando il template viene renderizzato.

Renderizzare i Template:

Per renderizzare un template, usa il metodo render() nel tuo gestore di richieste:

            class TemplateHandler(tornado.web.RequestHandler):
 def get(self):
  name = "John Doe"
  today = "2023-10-27"
  self.render("index.html", name=name, today=today)
            

              
                Copy
              
            
          

Assicurati che l'impostazione template_path sia configurata correttamente nelle impostazioni della tua applicazione. Di default, Tornado cerca i template in una directory chiamata templates nella stessa directory del file della tua applicazione.

            app = tornado.web.Application([
 (r"/template", TemplateHandler),
], template_path="templates")
            

              
                Copy
              
            
          

Sintassi dei Template:

I template di Tornado supportano varie funzionalità, tra cui:

• Variabili: {{ variable }}
• Flusso di Controllo: {% if condition %} ... {% else %} ... {% end %}, {% for item in items %} ... {% end %}
• Funzioni: {{ function(argument) }}
• Inclusioni: {% include "another_template.html" %}
• Escaping: Tornado esegue automaticamente l'escape delle entità HTML per prevenire attacchi di cross-site scripting (XSS). Puoi disabilitare l'escaping usando {% raw variable %}.

Operazioni Asincrone

La forza di Tornado risiede nelle sue capacità asincrone. Le operazioni asincrone consentono alla tua applicazione di eseguire I/O non bloccante, migliorando le prestazioni e la scalabilità. Ciò è particolarmente utile per attività che comportano l'attesa di risorse esterne, come query di database o richieste di rete.

@tornado.gen.coroutine:

Il decoratore @tornado.gen.coroutine ti consente di scrivere codice asincrono utilizzando la parola chiave yield. Questo fa sì che il codice asincrono appaia e si comporti più come codice sincrono, migliorando la leggibilità e la manutenibilità.

            import tornado.gen
import tornado.httpclient

class AsyncHandler(tornado.web.RequestHandler):
 @tornado.gen.coroutine
 def get(self):
  http_client = tornado.httpclient.AsyncHTTPClient()
  response = yield http_client.fetch("http://example.com")
  self.write(response.body.decode('utf-8'))
            

              
                Copy
              
            
          

In questo esempio, http_client.fetch() è un'operazione asincrona che restituisce un Future. La parola chiave yield sospende l'esecuzione della coroutine fino a quando il Future non viene risolto. Una volta che il Future è risolto, la coroutine riprende e il corpo della risposta viene scritto al client.

tornado.concurrent.Future:

Un Future rappresenta il risultato di un'operazione asincrona che potrebbe non essere ancora disponibile. Puoi usare oggetti Future per concatenare operazioni asincrone e gestire gli errori.

tornado.ioloop.IOLoop:

L'IOLoop è il cuore del motore asincrono di Tornado. Monitora i descrittori di file e i socket per eventi e li invia ai gestori appropriati. In genere non è necessario interagire direttamente con l'IOLoop, ma è importante comprendere il suo ruolo nella gestione delle operazioni asincrone.

WebSockets

Tornado fornisce un eccellente supporto per i WebSockets, consentendo la comunicazione in tempo reale tra il server e i client. I WebSockets sono ideali per applicazioni che richiedono una comunicazione bidirezionale a bassa latenza, come applicazioni di chat, giochi online e dashboard in tempo reale.

Creare un Gestore WebSocket:

Per creare un gestore WebSocket, si sottoclassa tornado.websocket.WebSocketHandler e si implementano i seguenti metodi:

• open(): Chiamato quando viene stabilita una nuova connessione WebSocket.
• on_message(message): Chiamato quando viene ricevuto un messaggio dal client.
• on_close(): Chiamato quando la connessione WebSocket viene chiusa.

            import tornado.websocket

class WebSocketHandler(tornado.websocket.WebSocketHandler):
 def open(self):
  print("WebSocket aperto")

 def on_message(self, message):
  self.write_message(f"Hai inviato: {message}")

 def on_close(self):
  print("WebSocket chiuso")

 def check_origin(self, origin):
  return True # Abilita le connessioni WebSocket cross-origin
            

              
                Copy
              
            
          

Integrare i WebSockets nella Tua Applicazione:

Aggiungi il gestore WebSocket alla configurazione di routing della tua applicazione:

            app = tornado.web.Application([
 (r"/ws", WebSocketHandler),
])
            

              
                Copy
              
            
          

Implementazione Lato Client:

Sul lato client, puoi usare JavaScript per stabilire una connessione WebSocket e inviare/ricevere messaggi:

            const websocket = new WebSocket("ws://localhost:8888/ws");

websocket.onopen = () => {
 console.log("Connessione WebSocket stabilita");
 websocket.send("Ciao dal client!");
};

websocket.onmessage = (event) => {
 console.log("Messaggio ricevuto:", event.data);
};

websocket.onclose = () => {
 console.log("Connessione WebSocket chiusa");
};
            

              
                Copy
              
            
          

Autenticazione e Sicurezza

La sicurezza è un aspetto critico dello sviluppo di applicazioni web. Tornado fornisce diverse funzionalità per aiutarti a proteggere le tue applicazioni, tra cui l'autenticazione, l'autorizzazione e la protezione contro le vulnerabilità web comuni.

Autenticazione:

L'autenticazione è il processo di verifica dell'identità di un utente. Tornado fornisce supporto integrato per vari schemi di autenticazione, tra cui:

• Autenticazione basata su cookie: Memorizza le credenziali dell'utente nei cookie.
• Autenticazione di terze parti (OAuth): Integrati con piattaforme di social media popolari come Google, Facebook e Twitter.
• Chiavi API: Usa chiavi API per autenticare le richieste API.

Autorizzazione:

L'autorizzazione è il processo per determinare se un utente ha il permesso di accedere a una particolare risorsa. Puoi implementare la logica di autorizzazione nei tuoi gestori di richieste per limitare l'accesso in base ai ruoli o ai permessi dell'utente.

Best Practice di Sicurezza:

• Protezione da Cross-Site Scripting (XSS): Tornado esegue automaticamente l'escape delle entità HTML per prevenire attacchi XSS. Usa sempre il metodo render() per renderizzare i template ed evita di generare HTML direttamente nei tuoi gestori di richieste.
• Protezione da Cross-Site Request Forgery (CSRF): Abilita la protezione CSRF nelle impostazioni della tua applicazione per prevenire attacchi CSRF.
• HTTPS: Usa sempre HTTPS per crittografare la comunicazione tra il server e i client.
• Validazione dell'Input: Valida tutti gli input dell'utente per prevenire attacchi di iniezione e altre vulnerabilità.
• Audit di Sicurezza Regolari: Conduci regolarmente audit di sicurezza per identificare e risolvere potenziali vulnerabilità.

Deployment

Il deployment di un'applicazione Tornado comporta diversi passaggi, tra cui la configurazione di un server web, l'impostazione di un gestore di processi e l'ottimizzazione delle prestazioni.

Web Server:

Puoi eseguire il deployment di Tornado dietro un web server come Nginx o Apache. Il web server funge da reverse proxy, inoltrando le richieste in arrivo all'applicazione Tornado.

Gestore di Processi:

Un gestore di processi come Supervisor o systemd può essere utilizzato per gestire il processo Tornado, assicurando che venga riavviato automaticamente in caso di crash.

Ottimizzazione delle Prestazioni:

• Usa un Event Loop Pronto per la Produzione: Usa un event loop pronto per la produzione come uvloop per prestazioni migliorate.
• Abilita la Compressione gzip: Abilita la compressione gzip per ridurre le dimensioni delle risposte HTTP.
• Metti in Cache i File Statici: Metti in cache i file statici per ridurre il carico sul server.
• Monitora le Prestazioni: Monitora le prestazioni della tua applicazione utilizzando strumenti come New Relic o Prometheus.

Internazionalizzazione (i18n) e Localizzazione (l10n)

Quando si creano applicazioni per un pubblico globale, è importante considerare l'internazionalizzazione (i18n) e la localizzazione (l10n). L'i18n è il processo di progettazione di un'applicazione in modo che possa essere adattata a varie lingue e regioni senza modifiche ingegneristiche. La l10n è il processo di adattamento di un'applicazione internazionalizzata per una lingua o regione specifica aggiungendo componenti specifici della locale e traducendo il testo.

Tornado e i18n/l10n

Tornado di per sé non ha librerie i18n/l10n integrate. Tuttavia, è possibile integrare facilmente librerie Python standard come `gettext` o framework più sofisticati come Babel per gestire i18n/l10n all'interno della tua applicazione Tornado.

Esempio usando `gettext`:

1. **Imposta le tue locali:** Crea directory per ogni lingua che vuoi supportare, contenenti i cataloghi dei messaggi (solitamente file `.mo`).

            locales/
 en/LC_MESSAGES/messages.mo
 fr/LC_MESSAGES/messages.mo
 de/LC_MESSAGES/messages.mo
            

              
                Copy
              
            
          

2. **Estrai le stringhe traducibili:** Usa uno strumento come `xgettext` per estrarre le stringhe traducibili dal tuo codice Python in un file `.po` (Portable Object). Questo file conterrà le stringhe originali e i segnaposto per le traduzioni.

            xgettext -d messages -o locales/messages.po your_tornado_app.py
            

              
                Copy
              
            
          

3. **Traduci le stringhe:** Traduci le stringhe nei file `.po` per ogni lingua.

4. **Compila le traduzioni:** Compila i file `.po` in file `.mo` (Machine Object) che vengono utilizzati da `gettext` a runtime.

            msgfmt locales/fr/LC_MESSAGES/messages.po -o locales/fr/LC_MESSAGES/messages.mo
            

              
                Copy
              
            
          

5. **Integra nella tua applicazione Tornado:**

            import gettext
import locale
import os
import tornado.web

class BaseHandler(tornado.web.RequestHandler):
 def initialize(self):
  try:
  locale.setlocale(locale.LC_ALL, self.get_user_locale().code)
  except locale.Error:
  # Gestisce i casi in cui la locale non è supportata dal sistema
  print(f"La locale {self.get_user_locale().code} non è supportata")

  translation = gettext.translation('messages', 'locales', languages=[self.get_user_locale().code])
  translation.install()
  self._ = translation.gettext

 def get_current_user_locale(self):
  # Logica per determinare la locale dell'utente (es. dall'header Accept-Language, impostazioni utente, ecc.)
  # Questo è un esempio semplificato - avrai bisogno di una soluzione più robusta
  accept_language = self.request.headers.get('Accept-Language', 'en')
  return tornado.locale.get(accept_language.split(',')[0].split(';')[0])

class MainHandler(BaseHandler):
 def get(self):
  self.render("index.html", _=self._)

settings = {
 "template_path": os.path.join(os.path.dirname(__file__), "templates"),
}

app = tornado.web.Application([
 (r"/", MainHandler),
], **settings)

            

              
                Copy
              
            
          

6. **Modifica i tuoi template:** Usa la funzione `_()` (associata a `gettext.gettext`) per contrassegnare le stringhe da tradurre nei tuoi template.

            <h1>{{ _("Benvenuti nel nostro sito web!") }}</h1>
<p>{{ _("Questo è un paragrafo tradotto.") }}</p>

            

              
                Copy
              
            
          

Considerazioni Importanti per un Pubblico Globale:

• **Codifica dei Caratteri:** Usa sempre la codifica UTF-8 per supportare un'ampia gamma di caratteri.
• **Formattazione di Data e Ora:** Usa la formattazione di data e ora specifica per la locale. Le funzioni `strftime` e `strptime` di Python possono essere utilizzate con le impostazioni della locale.
• **Formattazione dei Numeri:** Usa la formattazione dei numeri specifica per la locale (es. separatori decimali, separatori delle migliaia). Il modulo `locale` fornisce funzioni per questo.
• **Formattazione della Valuta:** Usa la formattazione della valuta specifica per la locale. Considera l'uso di una libreria come `Babel` per una gestione più avanzata della valuta.
• **Lingue da Destra a Sinistra (RTL):** Supporta le lingue RTL come l'arabo e l'ebraico. Questo può comportare il mirroring del layout del tuo sito web.
• **Qualità della Traduzione:** Affidati a traduttori professionisti per garantire traduzioni accurate e culturalmente appropriate. La traduzione automatica può essere un buon punto di partenza, ma spesso richiede una revisione umana.
• **Rilevamento della Locale dell'Utente:** Implementa un robusto rilevamento della locale basato sulle preferenze dell'utente, sulle impostazioni del browser o sull'indirizzo IP. Fornisci un modo per gli utenti di selezionare manualmente la loro lingua preferita.
• **Testing:** Testa approfonditamente la tua applicazione con diverse locali per assicurarti che tutto venga visualizzato correttamente.

Argomenti Avanzati

Pagine di Errore Personalizzate:

Puoi personalizzare le pagine di errore che Tornado visualizza quando si verifica un errore. Ciò ti consente di fornire un'esperienza più user-friendly e di includere informazioni di debug.

Impostazioni Personalizzate:

Puoi definire impostazioni personalizzate nella configurazione della tua applicazione e accedervi nei tuoi gestori di richieste. Questo è utile per memorizzare parametri specifici dell'applicazione, come stringhe di connessione al database o chiavi API.

Testing:

Testa approfonditamente le tue applicazioni Tornado per assicurarti che funzionino correttamente e in modo sicuro. Usa test unitari, test di integrazione e test end-to-end per coprire tutti gli aspetti della tua applicazione.

Conclusione

Tornado è un web framework potente e versatile, particolarmente adatto per la creazione di applicazioni web scalabili e ad alte prestazioni. La sua architettura asincrona, il supporto per i WebSockets e un'API facile da usare lo rendono una scelta popolare per gli sviluppatori di tutto il mondo. Seguendo le linee guida e gli esempi di questa guida completa, puoi iniziare a costruire le tue applicazioni Tornado e sfruttare le sue numerose funzionalità.

Ricorda di consultare la documentazione ufficiale di Tornado per le informazioni più aggiornate e le best practice. Buona programmazione!